home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / ingres04.lzh / source / parser / att_fcn.c < prev    next >
Encoding:
C/C++ Source or Header  |  1985-02-08  |  7.8 KB  |  431 lines
  1. # include    <ingres.h>
  2. # include    <aux.h>
  3. # include    <tree.h>
  4. # include    <symbol.h>
  5. # include    "parser.h"
  6. # include    <sccs.h>
  7. # include    <errors.h>
  8.  
  9. SCCSID(@(#)att_fcn.c    8.2    2/8/85)
  10.  
  11. /*
  12. ** fake attribute stash entries for tid nodes (and sid in dist version)
  13. **    these are provided by the system to a program only for debugging
  14. **    the system source and do not have well defined (over time) meanings.
  15. */
  16. struct atstash    Faketid =
  17. {
  18.     0,    INT,    4,    "tid",    0
  19. };
  20. #ifdef    DISTRIB
  21. struct atstash    Fakesid
  22. {
  23.     0,    INT,    4,    "sid",    0
  24. };
  25. #endif
  26.  
  27. struct atstash        Attable[MAXATT];/* attrib stash space, turned into a list later */
  28. struct atstash        *Freeatt;    /* free list of attrib stash */
  29.  
  30. /*
  31. **  ATT_FCN.C  --  attribute list manipulation routines
  32. **
  33. **    ATT_FCN ~~ trace flags = 40, 41
  34. **
  35. **    Defines:
  36. **        Attable
  37. **        Freeatt
  38. **        attinit()
  39. **        attlookup()
  40. **        attadd()
  41. **        attfnd()
  42. **        attcheck()
  43. **        attfree()
  44. **        attalloc()
  45. **        attcount()
  46. **
  47. **    History:
  48. **        modified for 6.3 (jiw)
  49. */
  50.  
  51. /*
  52. **   ATTINIT -- initializes attribute table
  53. **
  54. **    Parameters:
  55. **        none
  56. **
  57. **    Trace Flags:
  58. **        attinit ~~ 40.0
  59. */
  60.  
  61. attinit()
  62. {
  63.     register struct atstash        *atptr;
  64.     register int            i;
  65.  
  66. # ifdef    xPTR3
  67.     tTfp(40, 0, "attinit");
  68. # endif
  69.  
  70.     atptr = Attable;
  71.  
  72.     for (i = 0; i < MAXATT - 1; i++)
  73.     {
  74.         atptr->atbnext = atptr + 1;
  75.         atptr++;
  76.     }
  77.  
  78.     atptr->atbnext = NULL;
  79.  
  80.     Freeatt = Attable;        /* the first attribute in chain */
  81. }
  82.  
  83. /*
  84. **  ATTLOOKUP -- finds attribute entry
  85. **
  86. **    Attlookup looks up atribute 'attrib' in the att stash
  87. **    for range table entry 'slot'.  If the attrib is not
  88. **    in the stash it is entered.
  89. **
  90. **    Parameters:
  91. **        attrib -- the name of the attribute to find
  92. **        slot -- the number of the range variable
  93. **
  94. **    Returns:
  95. **        pointer to the attstash element
  96. **
  97. **    Trace Flags:
  98. **        attlookup ~~ 40.4, 40.5
  99. */
  100.  
  101. struct atstash *
  102. attlookup(slot, attrib)
  103. int        slot;
  104. char        *attrib;
  105. {
  106.     register PARRNG            *rptr;
  107.     register struct atstash        *current;
  108.     int                ik;
  109.     struct attribute        tuple;
  110.     register struct attribute    *ktuple;
  111.     struct attribute        ktup;
  112.     TID                tid;
  113.  
  114.     extern struct atstash        *attfind();
  115.     extern struct atstash        *attadd();
  116.     extern DESC            Attdes;
  117.     extern PARRNG            Parrng[];
  118.  
  119.     rptr = &Parrng[slot];
  120.  
  121.     ktuple = &ktup;
  122. #    ifdef    xPTR2
  123.     tTfp(40, 4, "attlookup: att = %s and rel= %s\n", attrib, trim_relname(rptr->vardesc.reldum.relid));
  124. #    endif
  125.  
  126.     /* attribute called "tid" is phantom attribute, use fake */
  127.     if (sequal("tid", attrib))
  128.         return (&Faketid);
  129. #    ifdef    DISTRIB
  130.     if (sequal("sid", attrib))
  131.         return (&Fakesid);
  132. #    endif
  133.  
  134.     /* check to see if attrib is in stash */
  135.     if ((current = attfind(slot, attrib)) != NULL)
  136.         return (current);
  137.  
  138. #    ifdef    xPTR2
  139.     tTfp(40, 5, "getting att info from relation\n");
  140. #    endif
  141.  
  142.     /* rel name, owner, attname is unique ident */
  143.     clearkeys(&Attdes);
  144.     setkey(&Attdes, ktuple, rptr->vardesc.reldum.relid, ATTRELID);
  145.     setkey(&Attdes, ktuple, rptr->vardesc.reldum.relowner, ATTOWNER);
  146.     setkey(&Attdes, ktuple, attrib, ATTNAME);
  147.     if (!(ik = getequal(&Attdes, ktuple, &tuple, &tid)))
  148.     {
  149.         /* put attrib stuff into att stash */
  150.         current = attadd(slot, &tuple);
  151.         return (current);
  152.     }
  153.  
  154.     if (ik == 1)
  155.         /* attribute not in relation */
  156.         par_error(NOATTRIN, WARN, attrib, trim_relname(rptr->vardesc.reldum.relid), 0);
  157.     else
  158.         syserr("fatal error in getequal, ret: %d", ik);
  159. }
  160.  
  161. /*
  162. **  ATTADD -- add an attribute to the list for a particular range variable
  163. **
  164. **    Parameters:
  165. **        slot -- the number of the range variable to use
  166. **        tuple -- the attribute tuple to add
  167. **
  168. **    Returns:
  169. **        pointer to the attribute added
  170. **
  171. **    Trace Flags:
  172. **        attadd ~~ 40.8
  173. */
  174.  
  175. struct atstash *
  176. attadd(slot, tuple)
  177. int            slot;
  178. struct attribute    *tuple;
  179. {
  180.     register struct atstash    *current;
  181.     register struct atstash    *aptr;
  182.     register struct atstash    *bptr;
  183.     PARRNG            *rptr;
  184.     int            i;
  185.  
  186.     extern struct atstash    *attalloc();
  187.     extern PARRNG        Parrng[];
  188.  
  189. # ifdef    xPTR3
  190.     tTfp(40, 8, "attadd slot %d, %12s\n", slot, tuple->attname);
  191. # endif
  192.  
  193.     rptr = &Parrng[slot];
  194.  
  195.     current = attalloc();
  196.     current->atbid = tuple->attid;
  197.     current->atbfrmt = tuple->attfrmt;
  198.     current->atbfrml = tuple->attfrml;
  199.     bmove(tuple->attname, current->atbname, MAXNAME);
  200.     for (i = 0; i < MAXNAME; i++)
  201.         if (current->atbname[i] == ' ')
  202.             current->atbname[i] = '\0';
  203.  
  204.     aptr = rptr->attlist;
  205.     bptr = 0;
  206.     while (aptr != 0)
  207.     {
  208.         if (aptr->atbid > current->atbid)
  209.             break;
  210.         bptr = aptr;
  211.         aptr = aptr->atbnext;
  212.     }
  213.     if (bptr == 0)
  214.         rptr->attlist = current;
  215.     else
  216.         bptr->atbnext = current;
  217.  
  218.     current->atbnext = aptr;
  219.  
  220.     return (current);
  221. }
  222.  
  223. /*
  224. **  ATTFIND -- finds attribute in stash
  225. **
  226. **    Attfind looks in attribute stash to see if attrib info already there
  227. **    return pointer to attribute in attribute table else NULL.
  228. **
  229. **    Parameters:
  230. **        slot -- the number of the entry in range table
  231. **        attrib -- the attribute name to find
  232. **
  233. **    Returns:
  234. **        pointer to entry or NULL if not in stash
  235. **
  236. **    Trace Flags:
  237. **        attfind ~~ 40.12
  238. */
  239.  
  240. struct atstash *
  241. attfind(slot, attrib)
  242. int        slot;
  243. register char    *attrib;
  244. {
  245.     register struct atstash    *aptr;
  246.  
  247.     extern PARRNG        Parrng[];
  248.  
  249. # ifdef xPTR1
  250.     tTfp(40, 12, "attadd\n");
  251. # endif
  252.  
  253.     aptr = Parrng[slot].attlist;
  254.  
  255.     while (aptr != NULL)
  256.     {
  257.         if (!scompare(attrib, MAXNAME, aptr->atbname, MAXNAME))
  258.             return (aptr);
  259.  
  260.         aptr = aptr->atbnext;
  261.     }
  262.     return (NULL);
  263. }
  264.  
  265. /*
  266. **  ATTCHECK -- checks for conflicts in attributes
  267. **
  268. **    Attcheck checks for type conflicts in the current query domain and
  269. **    attable entry
  270. **
  271. **    Parameters:
  272. **        aptr -- pointer to current atttibute
  273. **
  274. **    Returns:
  275. **        nothing
  276. **
  277. **    Requires:
  278. **        Trfrmt -- for current format
  279. **
  280. **    Trace Flags:
  281. **        attcheck ~~ 41.0
  282. */
  283.  
  284. attcheck(aptr)
  285. register struct atstash        *aptr;
  286. {
  287.     extern char        Trfrmt;
  288.  
  289. # ifdef    xPTR1
  290.     tTfp(41, 0, "attcheck\n");
  291. # endif
  292.  
  293.     if ((Trfrmt == CHAR) != (aptr->atbfrmt == CHAR))
  294.         /* function type does not match attrib */
  295.         par_error(RESTYPE, WARN, aptr->atbname, 0);
  296. }
  297.  
  298. /*
  299. **  ATTFREE -- puts a list of attrib space back on the free list
  300. **
  301. **    Parameters:
  302. **        aptr -- pointer to list of attstash entries
  303. **
  304. **    Returns:
  305. **        nothing
  306. **
  307. **    Requires:
  308. **        Freeatt
  309. **
  310. **    Trace Flags:
  311. **        attfree ~~ 41.4
  312. */
  313.  
  314. attfree(aptr)
  315. struct atstash    *aptr;
  316. {
  317.     register struct atstash    *att;
  318.  
  319. # ifdef    xPTR1
  320.     tTfp(41, 4, "attfree\n");
  321. # endif
  322.  
  323.     if ((att = aptr) == NULL)
  324.         return;
  325.  
  326.     while (att->atbnext != NULL)
  327.         att = att->atbnext;
  328.  
  329.     att->atbnext = Freeatt;
  330.     Freeatt = aptr;
  331. }
  332.  
  333. /*
  334. **  ATTALLOC -- returns a pointer to a atstash type structure
  335. **
  336. **    Attalloc checks the freelist (Freeatt) for attstash entries,
  337. **    if some is there, one is removed.  If the freelist is empty,
  338. **    attstashes are removed from range table entries until an free
  339. **    element is found.
  340. **
  341. **    Parameters:
  342. **        none
  343. **
  344. **    Returns:
  345. **        a pointer to an atstash element
  346. **
  347. **    Requires:
  348. **        Rngback
  349. **        Freeatt
  350. **        
  351. **    Trace Flags:
  352. **        attalloc ~~ 41.8, 41.9
  353. */
  354.  
  355. struct atstash *
  356. attalloc()
  357. {
  358.     register struct atstash    *aptr;
  359.     register PARRNG        *rptr;
  360.  
  361.     extern PARRNG        *Rngback;
  362.  
  363. # ifdef    xPTR3
  364.     tTfp(41, 8, "attalloc Freeatt %d\n", Freeatt);
  365. # endif
  366.  
  367.     /* Note: the following loop doesn't happen if Freeatt != NULL */
  368.  
  369.     for (rptr = Rngback; Freeatt == NULL; rptr = rptr->frontpt)
  370.     {
  371.         /*
  372.         ** search least recently used vbles for attrib stash space
  373.         ** until at least one entry is found
  374.         */
  375.  
  376. # ifdef    xPTR3
  377.     tTfp(41, 9, "attalloc: freeing %12s\n", rptr->vardesc.relvname);
  378. # endif
  379.  
  380.         if (rptr == NULL)
  381.             syserr("attalloc: no att space.");
  382.  
  383.         Freeatt = rptr->attlist;
  384.         rptr->attlist = NULL;
  385.     }
  386.     aptr = Freeatt;
  387.     Freeatt = Freeatt->atbnext;
  388.     aptr->atbnext = NULL;
  389.  
  390.     return (aptr);
  391. }
  392.  
  393. /*
  394. **  ATTCOUNT -- counts atstash elems
  395. **
  396. **    Attcount returns a count fof the number of attributes already in the
  397. **    attrib stash.
  398. **
  399. **    Parameter:
  400. **        slot -- the range table entry to count
  401. **
  402. **    Returns:
  403. **        count of the attributes
  404. **
  405. **    Trace Flags:
  406. **        attcount ~~ 41.12
  407. */
  408.  
  409. int
  410. attcount(slot)
  411. int    slot;
  412. {
  413.     register int        cntr;
  414.     register struct atstash    *aptr;
  415.  
  416.     extern PARRNG        Parrng[];
  417.  
  418. # ifdef    xPTR1
  419.     tTfp(41, 12, "attcount\n");
  420. # endif
  421.  
  422.     cntr = 0;
  423.     aptr = Parrng[slot].attlist;
  424.     while (aptr != NULL)
  425.     {
  426.         cntr++;
  427.         aptr = aptr->atbnext;
  428.     }
  429.     return (cntr);
  430. }
  431.